#ifndef _CHANNEL_MANANGER_H_
#define _CHANNEL_MANANGER_H_

#include "Common.h"
#include "Resource.h"
#include "ResourceManager.h"
#include "Singleton.h"
#include "String.h"
#include "Threading/ThreadStarter.h"
#include "Threading/QueueThreadPool.h"
#include "NGLog.h"


class ChannelPtr;

enum GameServerType
{
	GameServerTypeNone		= 0,	//无效的服务器类型
	GameServerTypeWorld		= 1,	//世界服务器类型
	GameServerTypeBattle		= 2	//战斗服务器类型
};

enum GameServerStatus
{
	GameServerStatusNone		= 0,	//无效错误的服务器状态
	GameServerStatusNormal		= 1,	//服务器运行中
	GameServerStatusFull		= 2,	//服务器负载满
	GameServerStatusStop		= 3,	//服务器停止
	GameServerStatusTimeout		= 4,	//服务器连接超时
	GameServerStatusError		= 5	//服务器错误状态
};

enum GameServerFlags
{
	GameServerFlagNone		= 0x00,		//无效的服务器标志
	GameServerFlagMaster		= 0x01,		//主登陆游戏服务器
	GameServerFlagSlave		= 0x02,		//从游戏服务器
};

typedef struct game_server_tag_
{
/* !#AUTO DATABASE TABLE GAME_SERVERS ST_DEF */
	
		/* '服务器id'*/
		uint32 	server_id;
		/* '服务器组id'*/
		uint32 	group_id;
		/* '服务器类型:1世界服务器;2房间服务器'*/
		uint32 	type;
		/* '服务器状态： 0  服务器错误  1正常 2 服务器满 3 停止状态 4 服务器更新超时 5 服务器错误 '*/
		uint32 	status;
		/* '保留服务器标志位'*/
		uint32 	flag;
		/* '服务器名称'*/
		String 	name;
		/* '服务器ip'*/
		String 	server_ip;
		/* '服务器端口'*/
		uint32 	port;
		/* '服务器ping时间'*/
		uint32 	last_ping;
		/* '最大连接数'*/
		uint32 	max_clients;
		/* '当前连接数'*/
		uint32 	current_clients;
		/* '服务区域 暂时只用于世界服务器'*/
		uint32 	region_x;
		/* '服务区域'*/
		uint32 	region_y;
		/* '服务区域'*/
		uint32 	region_width;
		/* '服务区域'*/
		uint32 	region_height;
		/* '服务器的游戏分区'*/
		uint32 	gz_id;
		/* '服务器发生链接转移的连接数'*/
		uint32 	trans_prop;
		/* '服务器链接补偿连接数'*/
		uint32 	recomp_prop;
		/* '服务器关闭的连接数'*/
		uint32 	close_prop;
		/* '服务器状态迁移的时间 单位为1970‘s 秒数'*/
		uint32 	time_prop;
/* #END DATABASE */
	
		float	load_factor;
		game_server_tag_()
		{
			load_factor = 0.0f;
		}
}GameServer;

typedef struct game_logs_tag_
{
/* !#AUTO DATABASE TABLE GAME_LOGS ST_DEF */
	
		/* '日志id'*/
		uint64 	log_id;
		/* '服务器组id'*/
		uint32 	group_id;
		/* '服务器id'*/
		uint32 	server_id;
		/* '日志状态 1 有效日志  2 删除日志'*/
		uint32 	status;
		/* '日志类型'*/
		uint32 	type;
		/* '日志子类型'*/
		uint32 	sub_type;
		/* '日志标志位'*/
		uint32 	flag;
		/* '平台id'*/
		uint32 	platform_id;
		/* '用户名称'*/
		String 	user_name;
		/* '用户呢名'*/
		String 	user_nick;
		/* '用户ip地址'*/
		String 	user_ip;
		/* '用户地址(城市)'*/
		String 	user_addr;
		/* '用户uid'*/
		uint32 	user_id;
		/* '角色id'*/
		uint32 	char_id;
		/* '源对象'*/
		uint32 	src_id;
		/* '源类型（对应程序中 resourcetype)'*/
		uint32 	src_type;
		/* '目标 id'*/
		uint32 	dest_id;
		/* '目标类型（对应程序中 resourcetype)'*/
		uint32 	dest_type;
		/* '对象id'*/
		uint32 	target_id;
		/* '对象类型（对应程序中 resourcetype)'*/
		uint32 	target_type;
		/* '整形数据1'*/
		int32 	data1;
		/* '整形数据2'*/
		int32 	data2;
		/* '整形数据3'*/
		int32 	data3;
		/* '整形数据4'*/
		int32 	data4;
		/* '整形数据5'*/
		int32 	data5;
		/* '整形数据6'*/
		int32 	data6;
		/* '整形数据7'*/
		int32 	data7;
		/* '整形数据8'*/
		int32 	data8;
		/* '无符号整形数据9'*/
		uint32 	data9;
		/* '无符号整形数据10'*/
		uint32 	data10;
		/* '无符号整形数据11'*/
		uint32 	data11;
		/* '无符号整形数据12'*/
		uint32 	data12;
		/* '整形数据13'*/
		int32 	data13;
		/* '整形数据14'*/
		int32 	data14;
		/* '整形数据15'*/
		int32 	data15;
		/* '整形数据16'*/
		int32 	data16;
		/* '大无符号整形数据1'*/
		uint64 	bdata1;
		/* '大无符号整形数据2'*/
		uint64 	bdata2;
		/* '大整形数据3'*/
		int64 	bdata3;
		/* '大整形数据4'*/
		int64 	bdata4;
		/* '浮点数据1'*/
		float 	fdata1;
		/* '浮点数据2'*/
		float 	fdata2;
		/* '浮点数据3'*/
		float 	fdata3;
		/* '浮点数据4'*/
		float 	fdata4;
		/* '字符串数据1'*/
		String 	sdata1;
		/* '字符串数据2'*/
		String 	sdata2;
		/* '字符串数据3'*/
		String 	sdata3;
		/* '字符串数据4'*/
		String 	sdata4;
		/* '字符串数据5'*/
		String 	sdata5;
		/* '字符串数据6'*/
		String 	sdata6;
		/* '字符串数据7'*/
		String 	sdata7;
		/* '字符串数据8'*/
		String 	sdata8;
		/* '用户xml数据'*/
		String 	user_data;
		/* '备注信息'*/
		String 	info;
		/* '日志创建时间'*/
		String 	create_time;
/* #END DATABASE */
}GameLog;

typedef struct game_march_tag_
{
/* !#AUTO DATABASE TABLE GAME_MARCH ST_DEF */
	
		/* '游戏记录id'*/
		uint64 	march_id;
		/* '服务器组id'*/
		uint32 	group_id;
		/* '服务器id'*/
		uint32 	server_id;
		/* '游戏记录 1 有效游戏记录  255 删除游戏记录'*/
		uint32 	status;
		/* '游戏记录类型'*/
		uint32 	type;
		/* '游戏记录子类型'*/
		uint32 	sub_type;
		/* '游戏记录标志位'*/
		uint32 	flag;
		/* '记录所有对象id'*/
		uint32 	owner_id;
		/* '记录所有对象类型（对应程序中 resourcetype)'*/
		uint32 	owner_type;
		/* '源对象'*/
		uint32 	src_id;
		/* '源类型（对应程序中 resourcetype)'*/
		uint32 	src_type;
		/* '目标 id'*/
		uint32 	dest_id;
		/* '目标类型（对应程序中 resourcetype)'*/
		uint32 	dest_type;
		/* '对象id'*/
		uint32 	target_id1;
		/* '对象类型（对应程序中 resourcetype)'*/
		uint32 	target_type1;
		/* '对象id'*/
		uint32 	target_id2;
		/* '对象类型（对应程序中 resourcetype)'*/
		uint32 	target_type2;
		/* '对象id'*/
		uint32 	target_id3;
		/* '对象类型（对应程序中 resourcetype)'*/
		uint32 	target_type3;
		/* '对象id'*/
		uint32 	target_id4;
		/* '对象类型（对应程序中 resourcetype)'*/
		uint32 	target_type4;
		/* '整形数据1'*/
		int32 	data1;
		/* '整形数据2'*/
		int32 	data2;
		/* '整形数据3'*/
		int32 	data3;
		/* '整形数据4'*/
		int32 	data4;
		/* '整形数据5'*/
		int32 	data5;
		/* '整形数据6'*/
		int32 	data6;
		/* '整形数据7'*/
		int32 	data7;
		/* '整形数据8'*/
		int32 	data8;
		/* '整形数据9'*/
		int32 	data9;
		/* '整形数据10'*/
		int32 	data10;
		/* '整形数据11'*/
		int32 	data11;
		/* '整形数据12'*/
		int32 	data12;
		/* '整形数据13'*/
		int32 	data13;
		/* '整形数据14'*/
		int32 	data14;
		/* '整形数据15'*/
		int32 	data15;
		/* '整形数据16'*/
		int32 	data16;
		/* '浮点数据1'*/
		float 	fdata1;
		/* '浮点数据2'*/
		float 	fdata2;
		/* '浮点数据3'*/
		float 	fdata3;
		/* '浮点数据4'*/
		float 	fdata4;
		/* '浮点数据5'*/
		float 	fdata5;
		/* '浮点数据6'*/
		float 	fdata6;
		/* '浮点数据7'*/
		float 	fdata7;
		/* '浮点数据8'*/
		float 	fdata8;
		/* '字符串数据1'*/
		String 	sdata1;
		/* '字符串数据2'*/
		String 	sdata2;
		/* '字符串数据3'*/
		String 	sdata3;
		/* '字符串数据4'*/
		String 	sdata4;
		/* '用户xml数据'*/
		String 	user_data;
		/* '备注信息'*/
		String 	info;
		/* '游戏记录创建时间'*/
		String 	create_time;
/* #END DATABASE */
}GameMarch;

typedef struct game_bank_tag_
{
/* !#AUTO DATABASE TABLE GAME_BANK ST_DEF */
	
		/* '银行id'*/
		uint64 	bank_id;
		/* '组id'*/
		uint32 	group_id;
		/* '平台id'*/
		uint32 	platform_id;
		/* '银行连接主id'*/
		uint64 	link_id;
		/* '类型 保留'*/
		uint32 	type;
		/* '状态  保留'*/
		uint32 	status;
		/* '最后操作的游戏分区'*/
		uint32 	gz_id;
		/* '源游戏分区'*/
		uint32 	src_gz_id;
		/* '目标游戏分区'*/
		uint32 	dest_gz_id;
		/* '源游戏id'*/
		uint32 	src_game_id;
		/* '目标游戏id'*/
		uint32 	dest_game_id;
		/* '游戏id'*/
		int32 	game_id;
		/* '最后操作的游戏分区用户id'*/
		uint32 	uid;
		/* '玩家名字'*/
		String 	name;
		/* '玩家昵名'*/
		String 	nick;
		/* '安全账号用户名'*/
		String 	login_name;
		/* '安全账号密码'*/
		String 	login_pass;
		/* '安全账号邮件'*/
		String 	email;
		/* '银行元宝数量'*/
		uint64 	golds;
		/* '银行铜币数'*/
		uint64 	coins;
		/* '银行参赛券'*/
		uint64 	march;
		/* '银行人人券'*/
		uint64 	rrj;
		/* '银行兑奖券'*/
		uint64 	prize;
		/* '银行物品1'*/
		uint64 	item1;
		/* '银行物品2'*/
		uint64 	item2;
		/* '银行物品3'*/
		uint64 	item3;
		/* '银行物品4'*/
		uint64 	item4;
		/* '银行物品5'*/
		uint64 	item5;
		/* '银行物品6'*/
		uint64 	item6;
		/* '银行物品7'*/
		uint64 	item7;
		/* '银行物品8'*/
		uint64 	item8;
		/* '银行物品9'*/
		uint64 	item9;
		/* '银行物品10'*/
		uint64 	item10;
		/* '银行物品11'*/
		int32 	item11;
		/* '银行物品12'*/
		int32 	item12;
		/* '银行物品13'*/
		int32 	item13;
		/* '银行物品14'*/
		int32 	item14;
		/* '银行物品15'*/
		int32 	item15;
		/* '银行物品16'*/
		int32 	item16;
		/* '银行物品17'*/
		int32 	item17;
		/* '银行物品18'*/
		int32 	item18;
		/* '银行物品19'*/
		int32 	item19;
		/* '银行物品20'*/
		int32 	item20;
		/* '用户xml数据'*/
		String 	user_data;
		/* '无符号整形数据1'*/
		uint32 	data1;
		/* '无符号整形数据2'*/
		uint32 	data2;
		/* '无符号整形数据3'*/
		uint32 	data3;
		/* '无符号整形数据4'*/
		uint32 	data4;
		/* '整形数据5'*/
		int32 	data5;
		/* '整形数据6'*/
		int32 	data6;
		/* '整形数据7'*/
		int32 	data7;
		/* '整形数据8'*/
		int32 	data8;
		/* '浮点数据1'*/
		float 	fdata1;
		/* '浮点数据2'*/
		float 	fdata2;
		/* '浮点数据3'*/
		float 	fdata3;
		/* '浮点数据4'*/
		float 	fdata4;
		/* '字符串数据1'*/
		String 	sdata1;
		/* '字符串数据2'*/
		String 	sdata2;
		/* '字符串数据3'*/
		String 	sdata3;
		/* '字符串数据4'*/
		String 	sdata4;
		/* '备注信息'*/
		String 	info;
		/* '银行创建时间'*/
		String 	create_time;
		/* '银行最后操作时间'*/
		uint32 	last_time;
/* #END DATABASE */
}GameBank;

typedef struct game_mail_tag_
{
/* !#AUTO DATABASE TABLE GAME_MAILS ST_DEF */
	
		/* '邮件id'*/
		uint32 	mail_id;
		/* '邮件组id'*/
		uint32 	group_id;
		/* '邮件标志(0x1 一般邮件 0x02 付费邮件 0x04 转账支付邮件 0x08 看信通知 0x10 收件确认通知 0x20 发送方隐藏 0x40 接收方隐藏)'*/
		uint32 	flag;
		/* '邮件状态 0 无效状态 1 草稿状态 2 邮件发送中 3 邮件到达 4 邮件打开 5  邮件关闭(结束)  6 邮件删除  7 处理错误'*/
		uint32 	status;
		/* '邮件付费价格  如果0为免费邮件'*/
		uint32 	price;
		/* '邮件支付状态 0 无支付状态 1 等待支付 2 买家已经支付 3 买家拒绝支付'*/
		uint32 	pay_status;
		/* '支付状态改变时间（支付或者拒绝)'*/
		uint32 	pay_time;
		/* '发件方'*/
		uint32 	send_serial;
		/* '发送方类型'*/
		uint32 	send_type;
		/* '接受方 serial'*/
		uint32 	recv_serial;
		/* '接受方 类型 1 武将 2 军队 3 物品'*/
		uint32 	recv_type;
		/* '邮件标题'*/
		String 	title;
		/* '邮件内容'*/
		String 	contenct;
		/* '物品附件1'*/
		uint32 	attath1;
		/* '物品附件2'*/
		uint32 	attath2;
		/* '物品附件3'*/
		uint32 	attath3;
		/* '物品附件4'*/
		uint32 	attath4;
		/* '附加数据1'*/
		int32 	data1;
		/* '附加数据2'*/
		int32 	data2;
		/* '附加数据3'*/
		int32 	data3;
		/* '附加数据4'*/
		int32 	data4;
		/* '浮点附加数据1'*/
		float 	fdata1;
		/* '浮点附加数据2'*/
		float 	fdata2;
		/* '邮件创建时间（秒）'*/
		uint32 	create_time;
		/* '邮件过期时间（秒)'*/
		uint32 	expiration_time;
/* #END DATABASE */
}GameMail;


enum GatewayCommandStatus
{
        GWCStatusWait           = 0,    //命令准备执行
        GWCStatusSucceed        = 1,    //命令执行成功
        GWCStatusError          = 2,    //命令执行错误
        GWCStatusProcess        = 3,     //命令服务器执行中
	GWCStatusForward	= 4,	//命令被转递
	GWCStatusTimeout	= 5	//命令执行超时
};

typedef struct gateway_command_tag_
{

/* !#AUTO DATABASE TABLE GW_COMMAND ST_DEF */
	
		/* '指令id'*/
		uint32 	cmdid;
		/* '会员id'*/
		uint32 	uid;
		/* '指令类型 1注册会员 2修改会员 3'*/
		uint32 	command_type;
		/* '服务器组id'*/
		uint32 	group_id;
		/* '服务器id'*/
		uint32 	server_id;
		/* '游戏分区id'*/
		uint32 	gz_id;
		/* '平台id'*/
		uint32 	pid;
		/* '代理商id'*/
		uint32 	agentid;
		/* '指令参数'*/
		String 	parameter;
		/* '指令提交时间'*/
		uint32 	addtime;
		/* '指令状态  0待执行 1执行成功 2执行失败 3执行完毕 4执行中'*/
		uint32 	cmd_status;
		/* '网关状态'*/
		uint32 	gw_status;
		/* '指令游戏执行 返回值'*/
		String 	result;
/* #END DATABASE */

	
		uint32	dest_server;	//发送指令目标服务器，默认为0 广播所有
		
		gateway_command_tag_()
		{
			dest_server = 0;
		}
}GatewayCommand;


//for server lock
#define WGS_SERVER_RW_MUTEX_NAME server_rw__mutex
#define WGS_SERVER_RW_MUTEX mutable boost::mutex WGS_SERVER_RW_MUTEX_NAME;
#define WGS_SERVER_RW_LOCK		boost::lock_guard<boost::mutex> wgsServerRWMutexLock(WGS_SERVER_RW_MUTEX_NAME);

class  ChannelManager: public ThreadRunableBase,public ResourceManager,public Singleton<ChannelManager>
{
protected:
	WGS_SERVER_RW_MUTEX
public:
	ChannelManager();
	~ChannelManager();

	String	getChannelStringName(const uint32 & serial);
	uint32	getChannelUid(uint32 sid,const String & name);
	
	ResourcePtr  create(const uint32 & serial,const NameValuePairList* params = 0);
	ResourceCreateOrRetrieveResult  \
		createOrRetrieve(const uint32 & serial,const NameValuePairList* params = 0);
	ResourcePtr  load(const uint32 & serial);
	ResourcePtr     reload(ResourceHandle handle);

	//user manager start
	void	Startup(const uint32 & server_id,const uint32 & gid,const bool & isBattle = false,	\
			const uint32 & thread_min =0 ,const uint32 & thread_max = 0, const bool & isolate = false);
	void 	Shutdown(void);

	//virual from  ThreadRunableBase
        bool  run(void *p);

	bool	StartChannelProcess(void);
	
	bool	StartIsolateChannelProcess(void);

	//添加一个频道到自动处理线程队列
	bool 	addChannelProcessQueue(ResourceProxy & channel);
	bool 	addChannelProcessQueue(ResourcePtr & channel);

	const uint32 & getServerID(void)	{	return m_server_id;	}
	const uint32 & getGroupID(void)		{	return m_default_gid;	}


	size_t 	getChannelList(std::list<ResourcePtr> & cList);

	const uint32 getCurrentUpdateTime(void)	{	return m_currentUpdateTime;	}

	//用于得到一个Channel结构，用于向数据库追加新效果的记录
	Resource * newDumyChannel(void);
	void	freeDumyChannel(Resource * dumy);

	//根据模板向数据库插入新的记录，返回插入的频道ID ， 不进行资源载入，只做数据库操作
	uint32 addChannelToDatabase(Resource * dumy);

	//根据模板向数据库插入数据，并创建资源，不载入
	ResourcePtr	createChannelDatabase(Resource * dumy);
	//根据模板向数据库插入数据 并返回载入的资源
	ResourcePtr	loadChannelDatabase(Resource * dumy);

	//得到最佳的战斗服务器  成功取得返回true 失败返回false
	bool getBestBattleServer(GameServer & server);
	//得到最空闲的战斗服务器
	bool getIdleBattleServer(GameServer & server);
	//得到最繁忙的战斗服务器
	bool getBusyBattleServer(GameServer & server);
	//得到最空闲的世界服务器
	bool getIdleWorldServer(GameServer & server);
	//得到最繁忙的世界服务器
	bool getBusyWorldServer(GameServer & server);

	//得到当前最佳的登录服务器，用于独立服务器分服
	bool getBestLoginServer(GameServer & server);
	
	//根据ServerID 得到服务器信息 成功取得返回true 失败返回false
	bool getGameServer(const uint32 & id,GameServer & server);
	//得到全部的服务器
	size_t	getAllServers(std::list<GameServer> * slist);
	

	//自动从数据库中载入准备处理的频道并开始处理
	bool	LoadChannelFromDB(void);
	
	// 服务器自动处理线程
	bool	ServerAutoProcess(void);
	//世界服务器自动载入战斗服务器处理完毕的战场
	bool	WorldLoadChannelFromDB(void);

	//自动处理服务器状态线程
	bool	ServerProcess(void);

	size_t	LoadGameServers(void);

	bool	isBattleServer(void)	{	return m_battle_server;	}

	//根据查询，返回符合条件的记录 offset 为翻页起点 limitcount 为取回角色最大数量 query 为查询条件在 WHERE之后
	bool	getChannelsList(std::list<ChannelPtr> * items,const uint32 & offset,const uint32 & limitcount,const char * query,...);

	//根据查询条件返回一个查询结果数量 query 为在WHERE之后的SQL语句
	uint32	getDBCount(const char * query,...);

	ResourcePtr   newDBObject(void);
	ResourcePtr   getDBObjectByHandle(const uint32 & handle);
	bool	getDBObjects(std::list<ResourcePtr> * objs,const uint32 & offset,const uint32 & limitcount,const char * query,...);

	//服务器日志
        GameLog *  newDumyLog(void);
        void    freeDumyLog(GameLog * dumy);

        //根据结构添加日志信息，返回0表示添加失败，成功返回log_id 
        uint64  addLogDB(GameLog * log);
        //根据结构，更新日志信息数据库
        bool    updateLogDB(GameLog * log);
        //根据日志ID,数据库删除日志
        bool    deleteLogDB(const uint32 & log_id);
        //根据日志ID，得到日志信息
        bool  getLogDB(const uint64 & log_id,GameLog * log);

	 //根据查询条件，返回一个查询结果 (本服务器)
        bool    getLogList(std::list<GameLog> * logs,const uint32 & offset,const uint32 & limitcount,const char * query,...);
        //更加??询条件 返回日志查询数量(本服务器)
        uint32 getLogDBCount(const char * query,...);
	
	//根据查询条件，返回一个查询结果 未指定服务器
        bool    getRawLogList(std::list<GameLog> * logs,const uint32 & offset,const uint32 & limitcount,const char * query,...);
        //更加??询条件 返回日志查询数量 未指定服务器
        uint32 getRawLogDBCount(const char * query,...);
	

	//服务器游戏记录
        GameMarch *  newDumyMarch(void);
        void    freeDumyMarch(GameMarch * dumy);

        //根据结构添加游戏记录信息，返回0表示添加失败，成功返回march_id 
        uint64  addMarchDB(GameMarch * march);
        //根据结构，更新游戏记录信息数据库
        bool    updateMarchDB(GameMarch * march);
        //根据游戏记录ID,数据库删除游戏记录
        bool    deleteMarchDB(const uint32 & march_id);
        //根据游戏记录ID，得到游戏记录信息
        bool  getMarchDB(const uint64 & march_id,GameMarch * march);

        //根据查询条件，返回一个查询结果
        bool    getMarchList(std::list<GameMarch> * marchs,const uint32 & offset,const uint32 & limitcount,const char * query,...);
        //更加??询条件 返回游戏记录查询数量
        uint32 getMarchDBCount(const char * query,...);

        //根据查询条件，返回一个查询结果 未指定服务器
        bool    getRawMarchList(std::list<GameMarch> * marchs,const uint32 & offset,const uint32 & limitcount,const char * query,...);
        //更加??询条件 返回游戏记录查询数量 未指定服务器
        uint32 getRawMarchDBCount(const char * query,...);

	//服务器银行日志
        GameLog *  newDumyCenterLog(void);
        void    freeDumyCenterLog(GameLog * dumy);

        //根据结构添加银行日志信息，返回0表示添加失败，成功返回log_id 
        uint64  addCenterLogDB(GameLog * log);
        //根据结构，更新银行日志信息数据库
        bool    updateCenterLogDB(GameLog * log);
        //根据银行日志ID,数据库删除银行日志
        bool    deleteCenterLogDB(const uint32 & log_id);
        //根据银行日志ID，得到银行日志信息
        bool  getCenterLogDB(const uint64 & log_id,GameLog * log);

	 //根据查询条件，返回一个查询结果 (本服务器)
        bool    getCenterLogList(std::list<GameLog> * logs,const uint32 & offset,const uint32 & limitcount,const char * query,...);
        //更加??询条件 返回银行日志查询数量(本服务器)
        uint32 getCenterLogDBCount(const char * query,...);
	
	//根据查询条件，返回一个查询结果 未指定服务器
        bool    getRawCenterLogList(std::list<GameLog> * logs,const uint32 & offset,const uint32 & limitcount,const char * query,...);
        //更加??询条件 返回银行日志查询数量 未指定服务器
        uint32 getRawCenterLogDBCount(const char * query,...);
	
	//服务器银行
        GameBank *  newDumyBank(void);
        void    freeDumyBank(GameBank * dumy);

        //根据结构添加银行信息，返回0表示添加失败，成功返回bank_id 
        uint64  addBankDB(GameBank * bank);
        //根据结构，更新银行信息数据库
        bool    updateBankDB(GameBank * bank);
        //根据银行ID,数据库删除银行
        bool    deleteBankDB(const uint32 & bank_id);
        //根据银行ID，得到银行信息
        bool  getBankDB(const uint64 & bank_id,GameBank * bank);

	 //根据查询条件，返回一个查询结果 (本服务器)
        bool    getBankList(std::list<GameBank> * banks,const uint32 & offset,const uint32 & limitcount,const char * query,...);
        //更加??询条件 返回银行查询数量(本服务器)
        uint32 getBankDBCount(const char * query,...);
	
	//根据查询条件，返回一个查询结果 未指定服务器
        bool    getRawBankList(std::list<GameBank> * banks,const uint32 & offset,const uint32 & limitcount,const char * query,...);
        //更加??询条件 返回银行查询数量 未指定服务器
        uint32 getRawBankDBCount(const char * query,...);
	
	//服务器邮件
        GameMail *  newDumyMail(void);
        void    freeDumyMail(GameMail * dumy);

        //根据结构添加邮件信息，返回0表示添加失败，成功返回mail_id 
        uint32  addMailDB(GameMail * mail);
        //根据结构，更新邮件信息数据库
        bool    updateMailDB(GameMail * mail);
        //根据邮件ID,数据库删除邮件
        bool    deleteMailDB(const uint32 & mail_id);
        //根据邮件ID，得到邮件信息
        bool  getMailDB(const uint32 & mail_id,GameMail * mail);

	 //根据查询条件，返回一个查询结果 (本服务器)
        bool    getMailList(std::list<GameMail> * mails,const uint32 & offset,const uint32 & limitcount,const char * query,...);
        //更加??询条件 返回邮件查询数量(本服务器)
        uint32 getMailDBCount(const char * query,...);
	
	//根据查询条件，返回一个查询结果 未指定服务器
        bool    getRawMailList(std::list<GameMail> * mails,const uint32 & offset,const uint32 & limitcount,const char * query,...);
        //更加??询条件 返回邮件查询数量 未指定服务器
        uint32 getRawMailDBCount(const char * query,...);
	
	
	
	//得到总世界在线和战斗在线
	const	uint32	& getDBWorldConnects(void)	{	return m_db_world_connects;	}
	const   uint32 & getDBBattleConnects(void)	{	return m_db_battle_connects;	}


protected:
	uint32		m_default_gid;
	String		m_default_group;
       /// @copydoc ResourceManager::createImpl
        Resource* createImpl(const String& name, ResourceHandle handle,
            const String& group, bool isManual, ManualResourceLoader* loader,
            const NameValuePairList* createParams);

	//自动频道检查启动
	volatile bool	m_autoChannelCheck;
	uint32		m_server_id;
	bool		m_battle_server;

	std::map<uint32,GameServer>	m_game_servers;
	uint32			m_last_server_time;
	uint32		m_thread_min;
	uint32		m_thread_max;


	//记录当前系统毫秒时间
	uint32		m_currentUpdateTime;

        //the auto process channel queue pool
        CQueueThreadPool<uint32>     m_ChannelProcessPool;
	
	//世界服务器战斗完毕 queue pool (world server only)
	CQueueThreadPool<uint32>	m_ChannelDonePool;
	

	uint32		m_db_world_connects;	//记录所有服务器世界在线数
	uint32		m_db_battle_connects;	//所有战斗服务器在线数	
};

//自动处理战场自动信息，将需要处理的战场放入请求队列中.
class ChannelThread : public ThreadBase
{       
        ChannelManager  * cm;
public: 
        ChannelThread(ChannelManager * s) :ThreadBase("ChannelThread"),cm(s) {}
        bool run()
        {
		Log.Debug("ChannelThread","Channel Process thread start.");       
                return cm->StartChannelProcess();
        }
};

//自动处理战场自动信息，将需要处理的战场放入请求队列中.
class IsolateChannelThread : public ThreadBase
{       
        ChannelManager  * cm;
public: 
        IsolateChannelThread(ChannelManager * s) :ThreadBase("ChannelThread"),cm(s) {}
        bool run()
        {
		Log.Debug("ChannelThread","Channel Process thread start.");       
                return cm->StartIsolateChannelProcess();
        }
};

//战斗服务器后台载入战场数据库中的频道，初始化相应信息
class LoadChannelThread : public ThreadBase
{
        ChannelManager  * cm;
public:
       LoadChannelThread(ChannelManager * s) :ThreadBase("BattleChannelThread"),cm(s) {}
        bool run()
        {
		Log.Debug("LoadChannelThread","Channel database load process thread start.");
                return cm->LoadChannelFromDB();
        }
};

//世界战场数据载入线程

class ServerAutoProcessThread:public ThreadBase
{
	ChannelManager * cm;
public:
	ServerAutoProcessThread(ChannelManager * s) :ThreadBase("ServerAutoProcessThread"),cm(s) {}
	bool run()
	{
		Log.Debug("ServerAutoProcessThread","Server Auto Process Thread Start.");
		return cm->ServerAutoProcess();
	}
};


class WorldLoadChannelThread:public ThreadBase
{
	ChannelManager * cm;
public:
	WorldLoadChannelThread(ChannelManager * s) :ThreadBase("WorldChannelThread"),cm(s) {}
	bool run()
	{
		Log.Debug("WorldChannelThread","Channel database load battle done thread start.");
		return cm->WorldLoadChannelFromDB();
	}
};

//服务器状态更新线程
class ServerProcessThread:public ThreadBase
{
	ChannelManager * cm;
public:
	ServerProcessThread(ChannelManager * s) :ThreadBase("ServerProcessThread"),cm(s) {}
	bool run()
	{
		Log.Debug("ServerProcessThread","Server Process thread start.");
		return cm->ServerProcess();
	}
};

//独立服务器处理战场的线程
class WorldIsolateChannelThread:public ThreadRunableBase
{
        ChannelManager * cm;
public:
        WorldIsolateChannelThread(ChannelManager * s):cm(s) {}
        //virual from  ThreadRunableBase
        bool  run(void *p);
};

//世界战场数据载入完成处理线程
class WorldChannelStatusProcessThread:public ThreadRunableBase
{
	ChannelManager * cm;
public:
	WorldChannelStatusProcessThread(ChannelManager * s):cm(s) {}
	//virual from  ThreadRunableBase
        bool  run(void *p);
};

//世界战场战斗完成处理线程
class WorldChannelStatusDoneThread:public ThreadRunableBase
{
        ChannelManager * cm;
public:
        WorldChannelStatusDoneThread(ChannelManager * s):cm(s) {}
        //virual from  ThreadRunableBase
        bool  run(void *p);
};	

//网关命令执行线程
class GatewayProcessThread:public ThreadBase
{
public:
        GatewayProcessThread() :ThreadBase("GatewayProcessThread") {}
        bool run();
};



#define   sChannelMgr   ChannelManager::getSingleton()



#endif
